-it('should have created a WORKSPACE_CREATED event', async () => {
-  const response = await fetchEvents(
-    eventService,
-    user1,
-    workspace1.id,
-    EventSource.WORKSPACE
-  )
-  ...
-})
+function testEventCreation(eventType, user, workspaceId) {
+  it(`should have created a ${eventType} event`, async () => {
+    const response = await fetchEvents(
+      eventService,
+      user,
+      workspaceId,
+      EventSource.WORKSPACE
+    )
+    ...
+  });
+}
+testEventCreation(EventType.WORKSPACE_CREATED, user1, workspace1.id);
 

-const response = await fetchEvents(
-  eventService,
-  user1,
-  workspace1.id,
-  EventSource.WORKSPACE
-)
-const event = response[0]
-expect(event).toBeDefined()
+async function fetchAndAssertEvent(user, workspaceId, eventType) {
+  const response = await fetchEvents(
+    eventService,
+    user,
+    workspaceId,
+    EventSource.WORKSPACE
+  )
+  expect(response.length).toBe(1)
+  const event = response[0]
+  expect(event.type).toBe(eventType)
+}
+await fetchAndAssertEvent(user1, workspace1.id, EventType.WORKSPACE_CREATED);
 

-it('should have created a PROJECT_CREATED event', async () => {
-  ...
-})
+const eventTests = [
+  { type: EventType.PROJECT_CREATED, id: undefined },
+  { type: EventType.PROJECT_UPDATED, id: project1.id },
+  { type: EventType.PROJECT_DELETED, id: project1.id },
+];
 
-it('should have created a PROJECT_UPDATED event', async () => {
-  ...
-})
+eventTests.forEach(({ type, id }) => {
+  it(`should have created a ${type} event`, async () => {
+    const response = await fetchEvents(eventService, user1, workspace1.id, EventSource.PROJECT);
+    const event = response[0];
+    expect(event.type).toBe(type);
+    if (id !== undefined) {
+      expect(event.itemId).toBe(id);
+    } else {
+      expect(event.itemId).toBeDefined();
+    }
+  });
+});
 
-it('should have created a PROJECT_DELETED event', async () => {
-  ...
-})
-

-it('should have created a SECRET_ADDED event', async () => {
-  ...
-})
+const secretEventTests = [
+  { type: EventType.SECRET_ADDED, id: undefined },
+  { type: EventType.SECRET_UPDATED, id: secret1.id },
+  { type: EventType.SECRET_DELETED, id: secret1.id },
+];
 
-it('should have created a SECRET_UPDATED event', async () => {
-  ...
-})
+secretEventTests.forEach(({ type, id }) => {
+  it(`should have created a ${type} event`, async () => {
+    const response = await fetchEvents(eventService, user1, workspace1.id, EventSource.SECRET);
+    const event = response[0];
+    expect(event.type).toBe(type);
+    if (id !== undefined) {
+      expect(event.itemId).toBe(id);
+    } else {
+      expect(event.itemId).toBeDefined();
+    }
+  });
+});
 
-it('should have created a SECRET_DELETED event', async () => {
-  ...
-})
-

-it('should have created a APPROVAL_CREATED event', async () => {
-  ...
-})
+const approvalEventTests = [
+  { type: EventType.APPROVAL_CREATED, id: undefined },
+  { type: EventType.APPROVAL_UPDATED, id: undefined },
+  { type: EventType.APPROVAL_APPROVED, id: undefined },
+  { type: EventType.APPROVAL_DELETED, id: undefined },
+  { type: EventType.APPROVAL_REJECTED, id: undefined },
+];
 
-it('should have created a APPROVAL_UPDATED event', async () => {
-  ...
-})
+approvalEventTests.forEach(({ type, id }) => {
+  it(`should have created a ${type} event`, async () => {
+    const response = await fetchEvents(eventService, user1, workspace1.id, EventSource.APPROVAL);
+    const event = response[0];
+    expect(event.type).toBe(type);
+    if (id !== undefined) {
+      expect(event.itemId).toBe(id);
+    } else {
+      expect(event.itemId).toBeDefined();
+    }
+  });
+});
 
-it('should have created a APPROVAL_APPROVED event', async () => {
-  ...
-})
-
-it('should have created a APPROVAL_DELETED event', async () => {
-  ...
-})
-
-it('should have created a APPROVAL_REJECTED event', async () => {
-  ...
-})
-

-await createEvent(
+await this.createWorkspaceEvent(
+  // Event details
+);
 

-if (severity && !Object.values(EventSeverity).includes(severity)) {
-  throw new BadRequestException('Invalid "severity" value')
+private validateSeverity(severity?: EventSeverity) {
+  if (severity && !Object.values(EventSeverity).includes(severity)) {
+    throw new BadRequestException('Invalid "severity" value');
+  }
 }
-if (source && !Object.values(EventSource).includes(source)) {
-  throw new BadRequestException('Invalid "source" value')
+private validateSource(source?: EventSource) {
+  if (source && !Object.values(EventSource).includes(source)) {
+    throw new BadRequestException('Invalid "source" value');
+  }
 }
 

+expect(response.length).toBe(1)
 const event = response[0]
-expect(event).toBeDefined()
 

-eventService = moduleRef.get(EventService)
+let eventService: EventService;
+beforeEach(() => {
+  eventService = moduleRef.get(EventService);
+});
 

 expect(event.type).toBe(EventType.WORKSPACE_CREATED)
 expect(event.workspaceId).toBe(workspace1.id)
+expect(event.timestamp).toBeDefined()
+expect(event.metadata).toBeDefined()
 

+expect(response.length).toBeGreaterThan(0)
 const event = response[0]
 

-// @ts-expect-error - Prisma does not have a type for severity
-return await this.prisma.event.findMany(query)
+interface EventQuery extends Prisma.EventFindManyArgs {
+  where: {
+    severity?: EventSeverity;
+  };
+}
+return await this.prisma.event.findMany(query as EventQuery)
 

-if (source) {
-  query.where['source'] = source
+const query = {
+  where: {
+    workspaceId,
+    title: {
+      contains: search
+    },
+    ...(source && { source }),
+  },
+  skip: page * limit,
+  take: limit,
+  orderBy: {
+    timestamp: 'desc'
+  }
 }
 

-await getWorkspaceWithAuthority(
-  user.id,
-  workspaceId,
-  Authority.READ_EVENT,
-  this.prisma
-)
+try {
+  await getWorkspaceWithAuthority(
+    user.id,
+    workspaceId,
+    Authority.READ_EVENT,
+    this.prisma
+  )
+} catch (error) {
+  throw new BadRequestException('Failed to verify workspace authority');
+}
 

-await createEvent(
+try {
+  await createEvent(
+    // Event details
+  );
+} catch (error) {
+  this.log.error('Failed to create event', error);
+}
 

+expect(response.length).toBeGreaterThan(0)
 const event = response[0]
 

-createEvent(
+await createEvent(
 

-skip: page * limit,
-take: limit,
+take: Math.min(limit, 100), // Assuming 100 is the maximum allowed limit